#ifndef __HV_HTTP_SERVER_XDG__HPP
#define __HV_HTTP_SERVER_XDG__HPP

#include <string>
#include <vector>

#include "hv/HttpServer.h"
#include "hv/HttpService.h"
#include "hv/hasync.h"      // 引入 hv::async 以启动后台线程池
#include "hv/hstring.h"   // 引入 strcasecmp 进行不区分大小写的比较
#include "hv/hsysinfo.h"

namespace xdg
{

    class HttpServer {

        /******************************************构造 / 析构函数******************************************/
    public:
        /**
         * @brief 构造函数
         * @param host 服务器监听地址 (默认0.0.0.0)
         * @param port 服务器监听端口 (默认8080)
         * @param port_ssl SSL端口 (默认0表示不启用SSL)
         * @param opt SSL上下文选项 (默认nullptr)
         */
        explicit HttpServer(const std::string& host = "0.0.0.0", int port = 8080, int port_ssl = 0, hssl_ctx_opt_t* opt = nullptr) {
            // 使用 std::make_unique 创建智能指针，确保异常安全
            m_httpServer = std::make_unique<hv::HttpServer>();
            m_httpService = std::make_unique<hv::HttpService>();

            // 配置服务器的网络参数
            m_httpServer->setHost(host.c_str());
            m_httpServer->setPort(port, port_ssl);

            // 如果提供了 SSL 选项，则配置 HTTPS
            if (port_ssl != 0 && opt != nullptr) {
                m_httpServer->newSslCtx(opt);
            }
        }

        // 析构函数，std::unique_ptr 会自动管理其指向的对象的生命周期
        ~HttpServer() {
            hv::async::cleanup();
        }

        /******************************************共有成员函数******************************************/
    public:
        /*------------------------------------------hv::HttpServer的方法------------------------------------------*/
#if __linux__
    /**
     * @brief (仅限Linux) 设置工作进程数
     * @param num 工作进程数量
     */
        inline void setProcessNum(int num) {
            m_httpServer->setProcessNum(num);
        }
#endif

        /**
         * @brief 设置工作线程数，设置的是工作线程的数量，不是同时能处理的客户端请求数量。
         * @param num 工作线程数量，0为CPU的核心数 * 2
         */
        inline void setThreadNum(size_t num) {
            if (num < 1) {  num = get_ncpu() * 2;  }
            m_workerThreadNum = num;
        }
        /**
         * @brief 设置hv::async 的后台线程池最小线程数
         * @param num 线程数量，0为CPU的核心数 * 2
         */
        inline void setMinAsyncThreads(size_t num) {
            if (num < 1) {  num = get_ncpu() * 2;  }
            m_minAsyncThreads = num;
        }
        /**
         * @brief 设置hv::async 的后台线程池最大线程数
         * @param num 工作线程数量，0为CPU的核心数 * 8
         */
        inline void setMaxAsyncThreads(size_t num) {
            if (num < 1) { num = get_ncpu() * 2; }
            m_maxAsyncThreads = num;
        }

        /**
         * @brief 启动HTTP服务器
         * @param wait 是否阻塞等待服务器停止 (默认true)
         */
        void start(bool wait = true) {
            if (m_workerThreadNum < 1) {  m_workerThreadNum = get_ncpu() * 2;  }
            m_httpServer->setThreadNum(m_workerThreadNum); // 设置工作线程数

            // 启动 hv::async 的后台线程池，用于执行异步任务
            if (m_minAsyncThreads < 1) { m_minAsyncThreads = get_ncpu() * 2; }
            if (m_maxAsyncThreads < 1) { m_maxAsyncThreads = get_ncpu() * 8; }
            hv::async::startup(m_minAsyncThreads, m_maxAsyncThreads);

            // 将 HttpService 注册到 HttpServer
            m_httpServer->registerHttpService(m_httpService.get());
            m_httpServer->run(NULL, wait);
        }

        /**
         * @brief 停止HTTP服务器
         */
        inline void stop() {
            m_httpServer->stop();
        }

        /*------------------------------------------hv::HttpService的方法------------------------------------------*/
           /**
           * @brief 添加静态资源映射
           * @param path 路由路径 (如"/static")
           * @param dir 本地文件目录 (如"./public")
           * @param isDocRoot 是否为文档根目录 (默认true)
           */
        inline void Static(const char* path, const char* dir, bool isDocRoot = true) {
            m_httpService->Static(path, dir);
            if (isDocRoot) { m_httpService->document_root = dir; }
        }

        /**
         * @brief 允许跨域访问 (CORS)
         */
        inline void AllowCORS() {
            m_httpService->AllowCORS();
        }

        /**
         * @brief 添加可信代理 (代理白名单)
         * @param host 代理主机 (如"192.168.1.0/24")
         */
        inline void AddTrustProxy(const char* host) {
            m_httpService->AddTrustProxy(host);
        }

        /**
         * @brief 添加不可信代理 (代理黑名单)
         * @param host 代理主机 (如"10.0.0.0/8")
         */
        inline void AddNoProxy(const char* host) {
            m_httpService->AddNoProxy(host);
        }

        /**
         * @brief 开启正向转发代理
         */
        inline void EnableForwardProxy() {
            m_httpService->EnableForwardProxy();
        }

        /**
         * @brief 添加反向代理映射
         * @param path 路由路径 (如"/api")
         * @param url 目标URL (如"http://backend:8080")
         */
        inline void Proxy(const char* path, const char* url) {
            m_httpService->Proxy(path, url);
        }

        /**
         * @brief 添加中间件
         * @param handlerFunc 中间件处理函数
         */
        inline void Use(http_sync_handler handlerFunc) {
            m_httpService->Use(handlerFunc);
        }

        /**
         * @brief 添加同步路由 (运行在IO线程)
         * @param method HTTP方法 (GET/POST/Any等)
         * @param path 路由路径
         * @param handler 同步处理函数
         */
        void addSyncRoute(const std::string& method, const std::string& path, const http_sync_handler handler) {
            if (strcasecmp(method.c_str(), "GET") == 0) { m_httpService->GET(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "POST") == 0) { m_httpService->POST(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "PUT") == 0) { m_httpService->PUT(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "DELETE") == 0) { m_httpService->Delete(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "PATCH") == 0) { m_httpService->PATCH(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "HEAD") == 0) { m_httpService->HEAD(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "ANY") == 0) { m_httpService->Any(path.c_str(), handler); }
            else { m_httpService->Handle(method.c_str(), path.c_str(), handler); }
        }

        /**
         * @brief 添加异步路由 (运行在全局线程池)
         * @param method HTTP方法
         * @param path 路由路径
         * @param handler 异步处理函数
         */
        void addAsyncRoute(const std::string& method, const std::string& path, const http_async_handler handler) {
            if (strcasecmp(method.c_str(), "GET") == 0) { m_httpService->GET(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "POST") == 0) { m_httpService->POST(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "PUT") == 0) { m_httpService->PUT(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "DELETE") == 0) { m_httpService->Delete(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "PATCH") == 0) { m_httpService->PATCH(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "HEAD") == 0) { m_httpService->HEAD(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "ANY") == 0) { m_httpService->Any(path.c_str(), handler); }
            else { m_httpService->Handle(method.c_str(), path.c_str(), handler); }
        }

        /**
         * @brief 添加上下文路由 (可传递HttpContext到其他线程)
         * @param method HTTP方法
         * @param path 路由路径
         * @param handler 上下文处理函数
         */
        void addCtxRoute(const std::string& method, const std::string& path, const http_ctx_handler handler) {
            if (strcasecmp(method.c_str(), "GET") == 0) { m_httpService->GET(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "POST") == 0) { m_httpService->POST(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "PUT") == 0) { m_httpService->PUT(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "DELETE") == 0) { m_httpService->Delete(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "PATCH") == 0) { m_httpService->PATCH(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "HEAD") == 0) { m_httpService->HEAD(path.c_str(), handler); }
            else if (strcasecmp(method.c_str(), "ANY") == 0) { m_httpService->Any(path.c_str(), handler); }
            else { m_httpService->Handle(method.c_str(), path.c_str(), handler); }
        }

        /**
         * @brief 返回注册的路由路径列表
         * @return 已注册路由路径列表
         */
        inline hv::StringList Paths() {
            return m_httpService->Paths();
        }

        /*------------------------------------------Getters 和 Setters (全部内联实现)------------------------------------------*/
        // 设置前处理器, 在中间件和API处理器之前执行
        inline void setPreprocessor(http_handler handler) { m_httpService->preprocessor = std::move(handler); }
        inline http_handler getPreprocessor() const { return m_httpService->preprocessor; }

        // 设置中间件队列
        inline void setMiddleware(const http_handlers& handlers) { m_httpService->middleware = handlers; }
        inline const http_handlers& getMiddleware() const { return m_httpService->middleware; }

        // 设置核心处理器 (通常由框架内部使用)
        inline void setProcessor(http_handler handler) { m_httpService->processor = std::move(handler); }
        inline http_handler getProcessor() const { return m_httpService->processor; }

        // 设置后处理器, 在API处理器执行之后执行
        inline void setPostprocessor(http_handler handler) { m_httpService->postprocessor = std::move(handler); }
        inline http_handler getPostprocessor() const { return m_httpService->postprocessor; }

        // 设置API的基础URL前缀 (如 "/api/v1")
        inline void setBaseUrl(const std::string& url) { m_httpService->base_url = url; }
        inline std::string getBaseUrl() const { return m_httpService->base_url; }

        // 设置静态文件服务的根目录
        inline void setDocumentRoot(const std::string& dir) { m_httpService->document_root = dir; }
        inline std::string getDocumentRoot() const { return m_httpService->document_root; }

        // 设置静态文件服务的默认主页 (如 "index.html"),相对于DocumentRoot的路径
        inline void setHomePage(const std::string& page) { m_httpService->home_page = page; }
        inline std::string getHomePage() const { return m_httpService->home_page; }

        // 设置默认的错误页面文件路径,相对于DocumentRoot的路径
        inline void setErrorPage(const std::string& page) { m_httpService->error_page = page; }
        inline std::string getErrorPage() const { return m_httpService->error_page; }

        // 设置开启目录浏览功能的路径前缀
        inline void setIndexOf(const std::string& dir) { m_httpService->index_of = dir; }
        inline std::string getIndexOf() const { return m_httpService->index_of; }

        // 设置统一的错误处理器
        inline void setErrorHandler(http_handler handler) { m_httpService->errorHandler = std::move(handler); }
        inline http_handler getErrorHandler() const { return m_httpService->errorHandler; }

        // 设置代理的连接超时时间 (毫秒)
        inline void setProxyConnectTimeout(int timeout) { m_httpService->proxy_connect_timeout = timeout; }
        inline int getProxyConnectTimeout() const { return m_httpService->proxy_connect_timeout; }

        // 设置代理的读超时时间 (毫秒)
        inline void setProxyReadTimeout(int timeout) { m_httpService->proxy_read_timeout = timeout; }
        inline int getProxyReadTimeout() const { return m_httpService->proxy_read_timeout; }

        // 设置代理的写超时时间 (毫秒)
        inline void setProxyWriteTimeout(int timeout) { m_httpService->proxy_write_timeout = timeout; }
        inline int getProxyWriteTimeout() const { return m_httpService->proxy_write_timeout; }

        // 设置HTTP长连接的保活超时时间 (毫秒)
        inline void setKeepaliveTimeout(int timeout) { m_httpService->keepalive_timeout = timeout; }
        inline int getKeepaliveTimeout() const { return m_httpService->keepalive_timeout; }

        // 设置静态文件内存缓存的最大尺寸 (字节)
        inline void setMaxFileCacheSize(int size) { m_httpService->max_file_cache_size = size; }
        inline int getMaxFileCacheSize() const { return m_httpService->max_file_cache_size; }

        // 设置检查文件缓存是否被修改的间隔时间 (秒)
        inline void setFileCacheStatInterval(int interval) { m_httpService->file_cache_stat_interval = interval; }
        inline int getFileCacheStatInterval() const { return m_httpService->file_cache_stat_interval; }

        // 设置文件缓存的过期时间 (秒)
        inline void setFileCacheExpiredTime(int time) { m_httpService->file_cache_expired_time = time; }
        inline int getFileCacheExpiredTime() const { return m_httpService->file_cache_expired_time; }

        // 设置下载速度限制 (KB/s)
        inline void setLimitRate(int rate) { m_httpService->limit_rate = rate; }
        inline int getLimitRate() const { return m_httpService->limit_rate; }

        /******************************************私有成员变量******************************************/
    private:
        std::unique_ptr<hv::HttpServer> m_httpServer; // 内部Http服务器
        std::unique_ptr<hv::HttpService> m_httpService; // 内部Http服务
        size_t m_workerThreadNum; // 工作线程数
        size_t m_minAsyncThreads; // 最小异步线程数
        size_t m_maxAsyncThreads; // 最大异步线程数

    }; // class HttpServer

} // namespace xdg

#endif // __HV_HTTP_SERVER_XDG__HPP